/*
    * Javassist, a Java-bytecode translator toolkit.
    * Copyright (C) 1999- Shigeru Chiba. All Rights Reserved.
    *
    * The contents of this file are subject to the Mozilla Public License Version
    * 1.1 (the "License"); you may not use this file except in compliance with
    * the License.  Alternatively, the contents of this file may be used under
    * the terms of the GNU Lesser General Public License Version 2.1 or later,
    * or the Apache License Version 2.0.
   *
   * Software distributed under the License is distributed on an "AS IS" basis,
   * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
   * for the specific language governing rights and limitations under the
   * License.
   */
  
  package scouter.javassist.bytecode;
  
  import java.io.ByteArrayOutputStream;
  import java.io.DataInputStream;
  import java.io.IOException;
  import java.util.HashMap;
  import java.util.Map;
  
  import scouter.javassist.bytecode.AttributeInfo;
  import scouter.javassist.bytecode.ConstPool;
  import scouter.javassist.bytecode.AnnotationsAttribute.Copier;
  import scouter.javassist.bytecode.AnnotationsAttribute.Parser;
  import scouter.javassist.bytecode.AnnotationsAttribute.Renamer;
  import scouter.javassist.bytecode.annotation.Annotation;
  import scouter.javassist.bytecode.annotation.AnnotationsWriter;
  
  
  /**
   * A class representing <code>RuntimeVisibleAnnotations_attribute</code> and
   * <code>RuntimeInvisibleAnnotations_attribute</code>.
   *
   * <p>To obtain an ParameterAnnotationAttribute object, invoke
   * <code>getAttribute(ParameterAnnotationsAttribute.invisibleTag)</code>
   * in <code>MethodInfo</code>.
   * The obtained attribute is a
   * runtime invisible annotations attribute.  
   * If the parameter is
   * <code>ParameterAnnotationAttribute.visibleTag</code>, then the obtained
   * attribute is a runtime visible one.
   */
  public class ParameterAnnotationsAttribute extends AttributeInfo {
      /**
       * The name of the <code>RuntimeVisibleParameterAnnotations</code>
       * attribute.
       */
      public static final String visibleTag
          = "RuntimeVisibleParameterAnnotations";
  
      /**
       * The name of the <code>RuntimeInvisibleParameterAnnotations</code>
       * attribute.
       */
      public static final String invisibleTag
          = "RuntimeInvisibleParameterAnnotations";
      /**
       * Constructs
       * a <code>Runtime(In)VisibleParameterAnnotations_attribute</code>.
       *
       * @param cp            constant pool
       * @param attrname      attribute name (<code>visibleTag</code> or
       *                      <code>invisibleTag</code>).
       * @param info          the contents of this attribute.  It does not
       *                      include <code>attribute_name_index</code> or
       *                      <code>attribute_length</code>.
       */
      public ParameterAnnotationsAttribute(ConstPool cp, String attrname,
                                           byte[] info) {
          super(cp, attrname, info);
      }
  
      /**
       * Constructs an empty
       * <code>Runtime(In)VisibleParameterAnnotations_attribute</code>.
       * A new annotation can be later added to the created attribute
       * by <code>setAnnotations()</code>.
       *
       * @param cp            constant pool
       * @param attrname      attribute name (<code>visibleTag</code> or
       *                      <code>invisibleTag</code>).
       * @see #setAnnotations(Annotation[][])
       */
      public ParameterAnnotationsAttribute(ConstPool cp, String attrname) {
          this(cp, attrname, new byte[] { 0 });
      }
  
      /**
       * @param n     the attribute name.
       */
      ParameterAnnotationsAttribute(ConstPool cp, int n, DataInputStream in)
          throws IOException
      {
          super(cp, n, in);
      }
 
     /**
      * Returns <code>num_parameters</code>. 
      */
     public int numParameters() {
         return info[0] & 0xff;
     }
 
     /**
      * Copies this attribute and returns a new copy.
      */
     public AttributeInfo copy(ConstPool newCp, Map classnames) {
         Copier copier = new Copier(info, constPool, newCp, classnames);
         try {
             copier.parameters();
             return new ParameterAnnotationsAttribute(newCp, getName(),
                                                      copier.close());
         }
         catch (Exception e) {
             throw new RuntimeException(e.toString());
         }
     }
 
     /**
      * Parses the annotations and returns a data structure representing
      * that parsed annotations.  Note that changes of the node values of the
      * returned tree are not reflected on the annotations represented by
      * this object unless the tree is copied back to this object by
      * <code>setAnnotations()</code>.
      *
      * @return Each element of the returned array represents an array of
      * annotations that are associated with each method parameter.
      *      
      * @see #setAnnotations(Annotation[][])
      */
     public Annotation[][] getAnnotations() {
         try {
             return new Parser(info, constPool).parseParameters();
         }
         catch (Exception e) {
             throw new RuntimeException(e.toString());
         }
     }
 
     /**
      * Changes the annotations represented by this object according to
      * the given array of <code>Annotation</code> objects.
      *
      * @param params        the data structure representing the
      *                      new annotations. Every element of this array
      *                      is an array of <code>Annotation</code> and
      *                      it represens annotations of each method parameter.
      */
     public void setAnnotations(Annotation[][] params) {
         ByteArrayOutputStream output = new ByteArrayOutputStream();
         AnnotationsWriter writer = new AnnotationsWriter(output, constPool);
         try {
             int n = params.length;
             writer.numParameters(n);
             for (int i = 0; i < n; ++i) {
                 Annotation[] anno = params[i];
                 writer.numAnnotations(anno.length);
                 for (int j = 0; j < anno.length; ++j)
                     anno[j].write(writer);
             }
 
             writer.close();
         }
         catch (IOException e) {
             throw new RuntimeException(e);      // should never reach here.
         }
 
         set(output.toByteArray());
     }
 
     /**
      * @param oldname       a JVM class name.
      * @param newname       a JVM class name.
      */
     void renameClass(String oldname, String newname) {
         HashMap map = new HashMap();
         map.put(oldname, newname);
         renameClass(map);
     }
 
     void renameClass(Map classnames) {
         Renamer renamer = new Renamer(info, getConstPool(), classnames);
         try {
             renamer.parameters();
         } catch (Exception e) {
             throw new RuntimeException(e);
         }
     }
 
     void getRefClasses(Map classnames) { renameClass(classnames); }
 
     /**
      * Returns a string representation of this object.
      */
     public String toString() {
         Annotation[][] aa = getAnnotations();
         StringBuilder sbuf = new StringBuilder();
         int k = 0;
         while (k < aa.length) {
             Annotation[] a = aa[k++]; 
             int i = 0;
             while (i < a.length) {
                 sbuf.append(a[i++].toString());
                 if (i != a.length)
                     sbuf.append(" ");
             }
 
             if (k != aa.length)
                 sbuf.append(", ");
         }
 
         return sbuf.toString();
 
     }
 }